#pragma once
#include <jsoncpp/json/json.h>
#include <iostream>
#include <string>
#include <chrono>
#include <random>
#include <sstream>
#include <atomic>
#include <iomanip>
#include "Log.hpp"
#include <cstdlib>
#include <ctime>

using namespace LogMudule;
namespace xu
{

    // 生成指定范围内的随机整数
    int generateRandomInt(int min, int max)
    {
        static bool isSeeded = false;
        if (!isSeeded)
        {
            std::srand(static_cast<unsigned int>(std::time(nullptr)));
            isSeeded = true;
        }
        return std::rand() % (max - min + 1) + min;
    }

    // 序列化和反序列化
    class JSON
    {
    public:
        // 序列化
        static bool Serialization(const Json::Value &val, std::string &out)
        {
            // 1.创建StreamWriterBuilder对象
            Json::StreamWriterBuilder swb;

            // 2.获取StreamWriter对象
            Json::StreamWriter *sw = swb.newStreamWriter();

            // 3.使用write进行序列化
            std::stringstream ss;
            int n = sw->write(val, &ss);
            if (n != 0)
            {
                LOG(LogLevel::ERROR) << "write erron ...";
                return false;
            }
            out = ss.str();

            delete sw;
            return true;
        }

        // 反序列化
        static bool Deserialization(const std::string &in, Json::Value &val)
        {
            // 1.创建CharReaderBuilder对象
            Json::CharReaderBuilder crb;

            // 2.获取CharReader对象
            Json::CharReader *cr = crb.newCharReader();

            // 3.使用parse进行序列化
            bool res = cr->parse(in.c_str(), in.c_str() + in.size(), &val, nullptr);
            if (!res)
            {
                LOG(LogLevel::ERROR) << "parse erron ...";
                return false;
            }

            delete cr;
            return true;
        }
    };

    class UUID
    {
    public:
        static std::string uuid()
        {
            std::stringstream ss;
            // 1. 构造⼀个机器随机数对象
            std::random_device rd;
            // 2. 以机器随机数为种⼦构造伪随机数对象
            std::mt19937 generator(rd());
            // 3. 构造限定数据范围的对象
            std::uniform_int_distribution<int> distribution(0, 255);
            // 4. ⽣成8个随机数，按照特定格式组织成为16进制数字字符的字符串
            for (int i = 0; i < 8; i++)
            {
                if (i == 4 || i == 6)
                    ss << "-";
                // std::setw(2):设置宽度为2，std::setfill('0')：设置不足宽度使用0补充，std::hex：整数以16进制输出
                ss << std::setw(2) << std::setfill('0') << std::hex << distribution(generator);
            }
            ss << "-";
            // 5. 定义⼀个8字节序号，逐字节组织成为16进制数字字符的字符串
            static std::atomic<size_t> seq(1); // 00 00 00 00 00 00 00 01
            size_t cur = seq.fetch_add(1);     // 原子+1
            for (int i = 7; i >= 0; i--)
            {
                if (i == 5)
                    ss << "-";
                ss << std::setw(2) << std::setfill('0') << std::hex << ((cur >> (i * 8)) & 0xFF);
            }
            return ss.str();
        }
    };

};